package com.sy.easycms.util;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.sy.easycms.hbm.HibernateSessionFactory;

/**
 * 该类为Hibernate应用提供简单支持 该类属于农场Java框架的一部分
 * 
 * @author Luke Sun
 * @version 2.3
 */
public class MyHibernateSupport {

	public MyHibernateSupport() {
	}

	/**
	 * 以指定的HibernateSession删除ORM实例
	 * 
	 * @param ormObject
	 * @param session
	 * @return
	 */
	public boolean delete(Object ormObject, Session session) {
		try {
			Transaction tra = session.beginTransaction();
			session.delete(ormObject);
			tra.commit();
			return true;
		} catch (Exception ex) {
			return false;
		} finally {
			session.close();
		}
	}

	/**
	 * 使用事务(基于同一个Hibernate Session)进行删除操作
	 * 
	 * @param ormObject
	 * @param session
	 * @param closable
	 * @return
	 */
	public boolean deleteTra(Object ormObject, Session session, boolean closable) {
		Transaction tra = session.getTransaction();
		try {
			session.delete(ormObject);
			if (closable) {
				tra.commit();
			}
			return true;
		} catch (Exception ex) {
			tra.rollback();
		} finally {
			if (closable) {
				if (session.isOpen()) {
					session.close();
				}
			}
		}
		return false;
	}

	/**
	 * 以指定的Hibernate Session删除指定类及ID的数据库记录
	 * 
	 * @param id
	 *            指定的ID
	 * @param type
	 *            指定的类型
	 * @param session
	 *            指定的Hibernate Session
	 * @return 删除成功true删除失败false
	 */
	public boolean delete(int id, Class type, Session session) {
		try {
			Transaction tra = session.beginTransaction();
			Object obj = session.get(type, id);
			session.delete(obj);
			tra.commit();
			return true;
		} catch (Exception ex) {
		} finally {
			if (session.isOpen()) {
				session.close();
			}
		}
		return false;
	}

	/**
	 * 使用事务(基于同一个HIbernate Session)进行删除操作
	 * 
	 * @param id
	 *            指定的ID
	 * @param type
	 *            指定的ORM类型
	 * @param session
	 *            指定的Hibernate Session
	 * @param closable
	 *            是否提交事务并关闭session
	 * @return
	 */
	public boolean deleteTra(int id, Class type, Session session,
			boolean closable) {
		Transaction tra = session.getTransaction();
		try {
			session.delete(session.get(type, id));
			if (closable) {
				tra.commit();
			}
			return true;
		} catch (Exception ex) {
			// TODO log4j
			tra.rollback();
			ex.printStackTrace();
		} finally {
			if (closable) {
				session.close();
			}
		}
		return false;
	}

	/**
	 * 以指定的Hibernate Session删除ORM对象数组
	 * 
	 * @param ormObjectArr
	 *            ORM对象的数组
	 * @param session
	 *            指定的Hibernate Session
	 * @return
	 */
	public boolean delete(Object[] ormObjectArr, Session session) {
		try {
			Transaction tra = session.beginTransaction();
			for (Object obj : ormObjectArr) {
				session.delete(obj);
			}
			tra.commit();
			return true;
		} catch (Exception ex) {
			return false;
		}
	}

	/**
	 * 使用事务(基于同一Hibernate Session)进行删除操作
	 * 
	 * @param ormObjectArr
	 *            要删除的对象数组
	 * @param session
	 *            指定的HIbernate Session
	 * @param closable
	 *            指定完成删除操作后是否需要提交事务并关闭Session
	 * @return
	 */
	public boolean deleteTra(Object[] ormObjectArr, Session session,
			boolean closable) {
		Transaction tra = session.getTransaction();
		try {
			for (Object obj : ormObjectArr) {
				session.delete(obj);
			}
			if (closable) {
				tra.commit();
			}
			return true;
		} catch (Exception ex) {
			tra.rollback();
			ex.printStackTrace();
		} finally {
			if (closable) {
				if (session.isOpen()) {
					session.close();
				}
			}
		}
		return true;
	}

	/**
	 * 以指定的Hibernate Session删除指定ID数组的ORM对象
	 * 
	 * @param arr
	 *            id数组
	 * @param type
	 *            ORM类
	 * @param session
	 *            指定的Hibernate Session
	 * @return
	 */
	public boolean delete(int[] arr, Class type, Session session) {
		try {
			Transaction tra = session.beginTransaction();
			for (int id : arr) {
				session.delete(session.get(type, id));
			}
			tra.commit();
			return true;
		} catch (Exception ex) {
			return false;
		}
	}

	/**
	 * 用事务(基于同一个Hibernate Session)进行删除操作
	 * 
	 * @param arr
	 * @param type
	 * @param session
	 * @param closable
	 * @return
	 */
	public boolean deleteTra(int[] arr, Class type, Session session,
			boolean closable) {
		Transaction tra = session.getTransaction();
		try {
			for (int id : arr) {
				session.delete(session.get(type, id));
			}
			if (closable) {
				tra.commit();
			}
			return true;
		} catch (Exception ex) {
			tra.rollback();
			ex.printStackTrace();
		} finally {
			if (closable) {
				if (session.isOpen()) {
					session.close();
				}
			}
		}
		return false;
	}

	/**
	 * 以指定的Hibernate Session更新ORM对象实例
	 * 
	 * @param ormObject
	 * @param session
	 * @return
	 */
	public boolean update(Object ormObject, Session session) {
		try {
			Transaction tra = session.beginTransaction();
			session.update(ormObject);
			tra.commit();
		} catch (Exception ex) {
			return false;
		} finally {
			if (session.isOpen()) {
				session.close();
			}
		}
		return true;
	}

	/**
	 * 以指定的Hibernate Session进行批量更新操作
	 * 
	 * @param ormObjectArr
	 * @param session
	 * @return
	 */
	public boolean update(Object[] ormObjectArr, Session session) {
		Transaction tra = session.beginTransaction();
		try {
			for (Object obj : ormObjectArr) {
				session.update(obj);
			}
			tra.commit();
			return true;
		} catch (Exception ex) {
			tra.rollback();
		} finally {
			if (session.isOpen()) {
				session.close();
			}
		}
		return false;
	}

	/**
	 * 用事务(基于同一Hibernate Session)来进行更新操作
	 * 
	 * @param ormObject
	 *            要更新的ORM对象
	 * @param session
	 *            指定的HIbernate Session
	 * @param closable
	 *            指定在完成更新操作后是否要提交事务并关闭连接
	 * @return
	 */
	public boolean updateTra(Object ormObject, Session session, boolean closable) {
		Transaction tra = session.getTransaction();
		try {
			session.update(ormObject);
			if (closable) {
				tra.commit();
			}
			return true;
		} catch (Exception ex) {
			tra.rollback();
			ex.printStackTrace();
		} finally {
			if (closable) {
				if (session.isOpen()) {
					session.close();
				}
			}
		}
		return false;
	}

	/**
	 * 以指定的Hibernate Session持久化ORM对象实体
	 * 
	 * @param ormObject
	 * @param session
	 * @return
	 */
	public boolean save(Object ormObject, Session session) {
		try {
			Transaction tra = session.beginTransaction();
			session.save(ormObject);
			tra.commit();
			return true;
		} catch (Exception ex) {
			return false;
		} finally {
			if (session.isOpen()) {
				session.close();
			}
		}
	}

	/**
	 * 用事务(基于同一Hibernate Session)进行保存操作.s
	 * 
	 * @param ormObject
	 *            指定的ORM对象
	 * @param session
	 *            指定的Hibernate Session
	 * @param closable
	 *            指示在完成保存操作之后是否提交事务并关闭连接
	 * @return
	 */
	public boolean saveTra(Object ormObject, Session session, boolean closable) {
		Transaction tra = session.getTransaction();
		try {
			session.save(ormObject);
			if (closable) {
				tra.commit();
			}
			return true;
		} catch (Exception ex) {
			tra.rollback();
			ex.printStackTrace();
		} finally {
			if (closable) {
				if (session.isOpen()) {
					session.close();
				}
			}
		}
		return false;
	}

	/**
	 * 使用指定的HQL语句及Hibernate Session进行查询
	 * 
	 * @param hql
	 * @param session
	 * @return
	 */
	public List find(String hql, Session session) {
		try {
			Transaction tra = session.beginTransaction();
			Query query = session.createQuery(hql);
			List list = query.list();
			tra.commit();
			return list;
		} catch (Exception e) {

		} finally {
			if (session.isOpen()) {
				session.close();
			}
		}
		return new ArrayList();
	}

	/**
	 * 使用事务进行查询操作
	 * 
	 * @param hql
	 *            指定的HQL语句
	 * @param session
	 *            指定的Hibernate Session
	 * @param closable
	 *            指示在完成查询之后是否提交事务并关闭连接
	 * @return
	 */
	public List findTra(String hql, Session session, boolean closable) {
		Transaction tra = session.getTransaction();
		try {
			Query query = session.createQuery(hql);
			List list = query.list();
			if (closable) {
				tra.commit();
			}
			return list;
		} catch (Exception ex) {
			tra.rollback();
			ex.printStackTrace();
		} finally {
			if (closable) {
				if (session.isOpen()) {
					session.close();
				}
			}
		}
		return new ArrayList();
	}

	/**
	 * 用事务进行查询操作
	 * 
	 * @param hql
	 *            指定的HQL语句
	 * @param params
	 *            指定的参数列表
	 * @param session
	 *            指定的Hibernate Session
	 * @param closable
	 *            指示在完成查询操作之后是否提交事务并关闭session
	 * @return
	 */
	public List findTra(String hql, Object[] params, Session session,
			boolean closable) {
		Transaction tra = session.getTransaction();
		try {
			Query query = session.createQuery(hql);
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					query.setParameter(i, params[i]);
				}
			}
			List list = query.list();
			if (closable) {
				tra.commit();
			}
			return list;
		} catch (Exception ex) {
			tra.rollback();
			ex.printStackTrace();
		} finally {
			if (closable) {
				if (session.isOpen()) {
					session.close();
				}
			}
		}
		return new ArrayList();
	}

	/**
	 * 以指定的Hibernate Session进行可设参数的HQL语句查询操作
	 * 
	 * @param hql
	 * @param params
	 * @param session
	 * @return
	 */
	public List find(String hql, Object[] params, Session session) {
		try {
			Transaction tra = session.beginTransaction();
			Query query = session.createQuery(hql);
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					query.setParameter(i, params[i]);
				}
			}
			List list = query.list();
			tra.commit();
			return list;
		} catch (Exception e) {

		} finally {
			if (session.isOpen()) {
				session.close();
			}
		}
		return new ArrayList();
	}

	/**
	 * 使用事务进行查询操作
	 * @param hql 指定的HQL语句
	 * @param session 指定的Hibernate Session
	 * @param offset 指定的偏移量
	 * @param start 指定的起始位置
	 * @param closable 指示在完成查询之后是否提交事务并关闭Session
	 * @return
	 */
	public List findTra(String hql, Session session, int offset, int start,
			boolean closable) {
		Transaction tra = session.getTransaction();
		try {
			Query query = session.createQuery(hql);
			List list = query.list();
			if (closable) {
				tra.commit();
			}
			return list;
		} catch (Exception ex) {
			tra.rollback();
			ex.printStackTrace();
		} finally {
			if (closable) {
				if (session.isOpen()) {
					session.close();
				}
			}
		}
		return new ArrayList();
	}

	/**
	 * 以指定的Hibernate Session进行HQL查询 从起始位置(Start)查询指定偏移量长度的数据(offset)
	 * 
	 * @param hql
	 * @param session
	 * @param offset
	 * @param start
	 * @return
	 */
	public List find(String hql, Session session, int offset, int start) {
		try {
			Transaction tra = session.beginTransaction();
			Query query = session.createQuery(hql);
			List list = query.list();
			query.setFirstResult(start);
			query.setMaxResults(offset);
			tra.commit();
			return list;
		} catch (Exception e) {

		} finally {
			if (session.isOpen()) {
				session.close();
			}
		}
		return new ArrayList();
	}

	/**
	 * 使用事务进行查询操作
	 * @param hql 指定的HQL语句
	 * @param params 指定的参数列表
	 * @param session 指定的Hibernate Session
	 * @param offset 指定的偏移量
	 * @param start 指定的起始位置
	 * @param closable 指示在完成查询后是否提交事务并关闭Session
	 * @return
	 */
	public List findTra(String hql,Object [] params,Session session,int offset,int start,boolean closable)
	{
		Transaction tra = session.getTransaction();
		try{
			Query query = session.createQuery(hql);
			if(params != null)
			{
				for(int i = 0;i<params.length;i++)
				{
					query.setParameter(i, params[i]);
				}
			}
			List list = query.list();
			if(closable)
			{
				tra.commit();
			}
			return list;
		}catch(Exception ex)
		{
			tra.rollback();
			ex.printStackTrace();
		}finally
		{
			if(closable)
			{
				if(session.isOpen())
				{
					session.close();
				}
			}
		}
		return new ArrayList();
	}
	/**
	 * 以指定的HQL及参数进行分页查询
	 * 
	 * @param hql
	 * @param params
	 * @param session
	 * @param offset
	 * @param start
	 * @return
	 */
	public List find(String hql, Object[] params, Session session, int offset,
			int start) {
		try {
			Transaction tra = session.beginTransaction();
			Query query = session.createQuery(hql);
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					query.setParameter(i, params[i]);
				}
			}
			query.setFirstResult(start);
			query.setMaxResults(offset);
			List list = query.list();
			tra.commit();
		} catch (Exception ex) {

		} finally {
			if (session.isOpen()) {
				session.close();
			}
		}
		return new ArrayList();
	}
	
	/**
	 * 以指定的HQL取得记录总数
	 * @param hql
	 * @return
	 */
//	public int getRecordCount(String hql)
//	{
//		Session session = HibernateSessionFactory.getSession();
//		Transaction tra = session.beginTransaction();
//		try{
//		Query query = session.createQuery(hql);
//		List list = query.list();
//		return Convert.toInt(list.get(0));
//		}catch(Exception ex)
//		{
//			
//			ex.printStackTrace();
//			tra.rollback();
//			return 0;
//		}finally
//		{
//			if(session.isOpen())
//			{
//				session.close();
//			}
//		}
//	}
}
